package com.southminority.ethnic.controller.admin;

import com.southminority.ethnic.common.annotation.RequireAdmin;
import com.southminority.ethnic.common.result.R;
import com.southminority.ethnic.mapper.MapLocationConfigMapper;
import com.southminority.ethnic.pojo.MapLocationConfig;
import com.southminority.ethnic.vo.MapLocationConfigVO;
import com.southminority.ethnic.vo.MapLocationConfigCreateReq;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.validation.Valid;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import org.springframework.util.StringUtils;

import java.time.LocalDateTime;
import java.util.List;
import java.util.stream.Collectors;

/**
 * 地图位置配置管理控制器
 * 
 * @author SouthMinority
 */
@Slf4j
@RestController
@RequestMapping("/admin/map-location")
@Tag(name = "地图位置配置管理", description = "地图位置配置相关接口")
@RequireAdmin
@Validated
public class MapLocationAdminController {

    @Autowired
    private MapLocationConfigMapper mapLocationConfigMapper;

    /**
     * 获取启用的地图位置配置列表
     */
    @GetMapping("/active")
    @Operation(summary = "获取启用的地图位置配置列表")
    public R<List<MapLocationConfigVO>> getActiveMapLocations() {
        try {
            log.info("📍 获取启用的地图位置配置列表");
            log.info("🔧 MapLocationConfigMapper: {}", mapLocationConfigMapper);
            
            List<MapLocationConfig> configs = mapLocationConfigMapper.selectActiveConfigs();
            log.info("📋 查询到的配置数量: {}", configs.size());
            
            List<MapLocationConfigVO> voList = configs.stream()
                    .map(this::convertToVO)
                    .collect(Collectors.toList());
            
            log.info("✅ 获取启用地图位置配置成功，数量: {}", voList.size());
            voList.forEach(vo -> log.info("🗺️ 地图位置: {} - [{}, {}]", vo.getTitle(), vo.getLongitude(), vo.getLatitude()));
            return R.success(voList);
        } catch (Exception e) {
            log.error("❌ 获取启用地图位置配置失败", e);
            return R.error("获取地图位置配置失败");
        }
    }

    /**
     * 获取地图位置配置详情
     */
    @GetMapping("/detail/{id}")
    @Operation(summary = "获取地图位置配置详情")
    public R<MapLocationConfigVO> getMapLocationDetail(@PathVariable Long id) {
        try {
            log.info("🔍 获取地图位置配置详情，ID: {}", id);
            
            MapLocationConfig config = mapLocationConfigMapper.selectById(id);
            if (config == null) {
                return R.error("地图位置配置不存在");
            }
            
            MapLocationConfigVO vo = convertToVO(config);
            log.info("✅ 获取地图位置配置详情成功");
            return R.success(vo);
        } catch (Exception e) {
            log.error("❌ 获取地图位置配置详情失败，ID: {}", id, e);
            return R.error("获取地图位置配置详情失败");
        }
    }

    /**
     * 获取默认地图位置配置
     */
    @GetMapping("/default")
    @Operation(summary = "获取默认地图位置配置")
    public R<MapLocationConfigVO> getDefaultMapLocation() {
        try {
            log.info("🎯 获取默认地图位置配置");
            
            MapLocationConfig config = mapLocationConfigMapper.selectDefaultConfig();
            if (config == null) {
                return R.error("未配置默认地图位置");
            }
            
            MapLocationConfigVO vo = convertToVO(config);
            log.info("✅ 获取默认地图位置配置成功");
            return R.success(vo);
        } catch (Exception e) {
            log.error("❌ 获取默认地图位置配置失败", e);
            return R.error("获取默认地图位置配置失败");
        }
    }

    /**
     * 根据机构ID获取地图位置配置
     */
    @GetMapping("/organization/{organizationId}")
    @Operation(summary = "根据机构ID获取地图位置配置")
    public R<List<MapLocationConfigVO>> getMapLocationsByOrganization(@PathVariable Long organizationId) {
        try {
            log.info("🏢 根据机构ID获取地图位置配置，机构ID: {}", organizationId);
            
            List<MapLocationConfig> configs = mapLocationConfigMapper.selectByOrganizationId(organizationId);
            List<MapLocationConfigVO> voList = configs.stream()
                    .map(this::convertToVO)
                    .collect(Collectors.toList());
            
            log.info("✅ 根据机构ID获取地图位置配置成功，数量: {}", voList.size());
            return R.success(voList);
        } catch (Exception e) {
            log.error("❌ 根据机构ID获取地图位置配置失败，机构ID: {}", organizationId, e);
            return R.error("获取地图位置配置失败");
        }
    }

    /**
     * 创建地图位置配置
     */
    @PostMapping("/create")
    @Operation(summary = "创建地图位置配置")
    public R<MapLocationConfigVO> createMapLocation(@Valid @RequestBody MapLocationConfigCreateReq request) {
        try {
            log.info("📍 创建地图位置配置: {}", request.getTitle());
            
            // 检查名称是否已存在
            MapLocationConfig existingConfig = mapLocationConfigMapper.selectByName(request.getName());
            if (existingConfig != null) {
                return R.error("位置名称已存在");
            }
            
            // 如果设置为默认位置，需要先取消其他默认位置
            if (request.getIsDefault() != null && request.getIsDefault() == 1) {
                resetOtherDefaultConfigs();
            }
            
            MapLocationConfig config = new MapLocationConfig();
            BeanUtils.copyProperties(request, config);
            config.setCreateTime(LocalDateTime.now());
            config.setUpdateTime(LocalDateTime.now());
            
            int result = mapLocationConfigMapper.insert(config);
            if (result > 0) {
                log.info("✅ 地图位置配置创建成功，ID: {}", config.getId());
                return R.success("创建成功", convertToVO(config));
            } else {
                return R.error("创建失败");
            }
        } catch (Exception e) {
            log.error("❌ 创建地图位置配置失败", e);
            return R.error("创建地图位置配置失败");
        }
    }

    /**
     * 更新地图位置配置
     */
    @PutMapping("/update/{id}")
    @Operation(summary = "更新地图位置配置")
    public R<MapLocationConfigVO> updateMapLocation(@PathVariable Long id, 
                                                   @Valid @RequestBody MapLocationConfigCreateReq request) {
        try {
            log.info("📝 更新地图位置配置，ID: {}", id);
            
            MapLocationConfig existingConfig = mapLocationConfigMapper.selectById(id);
            if (existingConfig == null) {
                return R.error("地图位置配置不存在");
            }
            
            // 检查名称是否与其他记录冲突
            MapLocationConfig configWithSameName = mapLocationConfigMapper.selectByName(request.getName());
            if (configWithSameName != null && !configWithSameName.getId().equals(id)) {
                return R.error("位置名称已存在");
            }
            
            // 如果设置为默认位置，需要先取消其他默认位置
            if (request.getIsDefault() != null && request.getIsDefault() == 1) {
                resetOtherDefaultConfigs();
            }
            
            BeanUtils.copyProperties(request, existingConfig);
            existingConfig.setUpdateTime(LocalDateTime.now());
            
            int result = mapLocationConfigMapper.updateById(existingConfig);
            if (result > 0) {
                log.info("✅ 地图位置配置更新成功");
                return R.success("更新成功", convertToVO(existingConfig));
            } else {
                return R.error("更新失败");
            }
        } catch (Exception e) {
            log.error("❌ 更新地图位置配置失败，ID: {}", id, e);
            return R.error("更新地图位置配置失败");
        }
    }

    /**
     * 删除地图位置配置
     */
    @DeleteMapping("/delete/{id}")
    @Operation(summary = "删除地图位置配置")
    public R<Boolean> deleteMapLocation(@PathVariable Long id) {
        try {
            log.info("🗑️ 删除地图位置配置，ID: {}", id);
            
            MapLocationConfig config = mapLocationConfigMapper.selectById(id);
            if (config == null) {
                return R.error("地图位置配置不存在");
            }
            
            int result = mapLocationConfigMapper.deleteById(id);
            if (result > 0) {
                log.info("✅ 地图位置配置删除成功");
                return R.success("删除成功", true);
            } else {
                return R.error("删除失败");
            }
        } catch (Exception e) {
            log.error("❌ 删除地图位置配置失败，ID: {}", id, e);
            return R.error("删除地图位置配置失败");
        }
    }

    /**
     * 设置为默认地图位置
     */
    @PutMapping("/set-default/{id}")
    @Operation(summary = "设置为默认地图位置")
    public R<Boolean> setDefaultMapLocation(@PathVariable Long id) {
        try {
            log.info("🎯 设置默认地图位置，ID: {}", id);
            
            MapLocationConfig config = mapLocationConfigMapper.selectById(id);
            if (config == null) {
                return R.error("地图位置配置不存在");
            }
            
            // 先取消其他默认位置
            resetOtherDefaultConfigs();
            
            // 设置当前为默认位置
            config.setIsDefault(1);
            config.setUpdateTime(LocalDateTime.now());
            
            int result = mapLocationConfigMapper.updateById(config);
            if (result > 0) {
                log.info("✅ 默认地图位置设置成功");
                return R.success("设置成功", true);
            } else {
                return R.error("设置失败");
            }
        } catch (Exception e) {
            log.error("❌ 设置默认地图位置失败，ID: {}", id, e);
            return R.error("设置默认地图位置失败");
        }
    }

    /**
     * 启用/禁用地图位置配置
     */
    @PutMapping("/toggle-status/{id}")
    @Operation(summary = "启用/禁用地图位置配置")
    public R<Boolean> toggleMapLocationStatus(@PathVariable Long id) {
        try {
            log.info("🔄 切换地图位置状态，ID: {}", id);
            
            MapLocationConfig config = mapLocationConfigMapper.selectById(id);
            if (config == null) {
                return R.error("地图位置配置不存在");
            }
            
            // 切换状态
            config.setIsActive(config.getIsActive() == 1 ? 0 : 1);
            config.setUpdateTime(LocalDateTime.now());
            
            int result = mapLocationConfigMapper.updateById(config);
            if (result > 0) {
                log.info("✅ 地图位置状态切换成功，新状态: {}", config.getIsActive() == 1 ? "启用" : "禁用");
                return R.success("状态切换成功", true);
            } else {
                return R.error("状态切换失败");
            }
        } catch (Exception e) {
            log.error("❌ 切换地图位置状态失败，ID: {}", id, e);
            return R.error("切换地图位置状态失败");
        }
    }

    /**
     * 重置其他默认配置
     */
    private void resetOtherDefaultConfigs() {
        try {
            List<MapLocationConfig> defaultConfigs = mapLocationConfigMapper.selectActiveConfigs();
            for (MapLocationConfig config : defaultConfigs) {
                if (config.getIsDefault() == 1) {
                    config.setIsDefault(0);
                    config.setUpdateTime(LocalDateTime.now());
                    mapLocationConfigMapper.updateById(config);
                }
            }
        } catch (Exception e) {
            log.warn("⚠️ 重置其他默认配置时出现异常", e);
        }
    }

    /**
     * 转换为VO对象
     */
    private MapLocationConfigVO convertToVO(MapLocationConfig config) {
        MapLocationConfigVO vo = new MapLocationConfigVO();
        BeanUtils.copyProperties(config, vo);
        return vo;
    }
} 